// 云函数入口文件
const cloud = require('wx-server-sdk')

cloud.init({
  env: cloud.DYNAMIC_CURRENT_ENV
})

const db = cloud.database()
const _ = db.command

// 验证Token
async function validateToken(token) {
  try {
    console.log('开始验证Token:', token)
    
    const tokenResult = await db.collection('user_tokens')
      .where({
        token: token,
        expireTime: _.gte(new Date())
      })
      .get()
    
    console.log('Token查询结果 - 找到记录数:', tokenResult.data.length)
    
    if (tokenResult.data.length === 0) {
      console.log('Token无效或已过期')
      return { valid: false, message: 'Token无效或已过期' }
    }
    
    const tokenData = tokenResult.data[0]
    console.log('Token数据:', {
      userId: tokenData.userId,
      createTime: tokenData.createTime,
      expireTime: tokenData.expireTime
    })
    
    const userResult = await db.collection('users').doc(tokenData.userId).get()
    console.log('用户查询结果:', userResult.data ? '用户存在' : '用户不存在')
    
    if (!userResult.data) {
      console.log('用户不存在，userId:', tokenData.userId)
      return { valid: false, message: '用户不存在' }
    }
    
    console.log('Token验证成功，用户名:', userResult.data.username)
    
    return { 
      valid: true, 
      user: userResult.data,
      userId: tokenData.userId 
    }
  } catch (error) {
    console.error('Token验证错误:', error)
    return { valid: false, message: 'Token验证失败' }
  }
}

// 云函数入口函数
exports.main = async (event, context) => {
  const wxContext = cloud.getWXContext()
  const { action, data, token } = event

  try {
    switch (action) {
      case 'getUserInfo':
        return await getUserInfo(data, token)
      case 'getPersonalInfo':
        return await getPersonalInfo(data, token)
      case 'updateUserInfo':
        return await updateUserInfo(data, token)
      case 'changePassword':
        return await changePassword(data, token)
      case 'changePasswordWithoutOld':
        return await changePasswordWithoutOld(data, token)
      case 'getUserList':
        return await getUserList(data, token)
      case 'resetPassword':
        return await resetPassword(data, token)
      case 'setUserStatus':
        return await setUserStatus(data, token)
      case 'deleteUser':
        return await deleteUser(data, token)
      case 'getUserStats':
        return await getUserStats(token)
      default:
        return {
          success: false,
          code: 400,
          message: '不支持的操作类型'
        }
    }
  } catch (error) {
    console.error('用户管理云函数执行错误:', error)
    return {
      success: false,
      code: 500,
      message: '服务器内部错误'
    }
  }
}

// 获取用户信息
async function getUserInfo(data, token) {
  const { userId } = data
  
  // 验证token
  const tokenValidation = await validateToken(token)
  if (!tokenValidation.valid) {
    return {
      success: false,
      code: 401,
      message: tokenValidation.message
    }
  }
  
  try {
    // 如果没有指定userId，返回当前用户信息
    const targetUserId = userId || tokenValidation.userId
    
    const userResult = await db.collection('users').doc(targetUserId).get()
    
    if (!userResult.data) {
      return {
        success: false,
        code: 404,
        message: '用户不存在'
      }
    }
    
    const user = userResult.data
    
    // 移除敏感信息
    delete user.password
    delete user.openid
    
    // 添加额外信息
    const enrichedUser = {
      ...user,
      id: user._id,
      role: user.role || 'user',
      level: user.level || '普通用户',
      permissions: user.permissions || ['view_own_tasks'],
      isVip: user.role === 'vip' || user.level === 'VIP会员',
      points: user.points || 0 // 添加积分信息
    }
    
    return {
      success: true,
      code: 200,
      message: '获取用户信息成功',
      data: enrichedUser
    }
  } catch (error) {
    console.error('获取用户信息错误:', error)
    return {
      success: false,
      code: 500,
      message: '获取用户信息失败'
    }
  }
}

// 获取个人信息（为个人中心页面提供数据）
async function getPersonalInfo(data, token) {
  // 验证token
  const tokenValidation = await validateToken(token)
  if (!tokenValidation.valid) {
    return {
      success: false,
      code: 401,
      message: tokenValidation.message
    }
  }
  
  try {
    // 获取当前登录用户的信息
    const userResult = await db.collection('users').doc(tokenValidation.userId).get()
    
    if (!userResult.data) {
      return {
        success: false,
        code: 404,
        message: '用户不存在'
      }
    }
    
    const user = userResult.data
    
    // 构建个人信息数据
    const personalInfo = {
      name: user.nickname || user.username || '用户',
      image: user.avatar || '',
      star: '0', // 可以根据用户等级设置
      city: user.city || '未知',
      phone: user.phone || '',
      email: user.email || '',
      role: user.role || 'user',
      level: user.level || '普通用户',
      nickname: user.nickname || user.username,
      username: user.username,
      avatar: user.avatar,
      gender: user.gender || 0,
      birth: user.birth || '',
      address: user.address || [],
      introduction: user.introduction || '',
      photos: user.photos || [],
      points: user.points || 0 // 添加积分信息
    }
    
    return {
      success: true,
      code: 200,
      message: '获取个人信息成功',
      data: personalInfo
    }
  } catch (error) {
    console.error('获取个人信息错误:', error)
    return {
      success: false,
      code: 500,
      message: '获取个人信息失败'
    }
  }
}

// 更新用户信息
async function updateUserInfo(data, token) {
  // 验证token
  const tokenValidation = await validateToken(token)
  if (!tokenValidation.valid) {
    return {
      success: false,
      code: 401,
      message: tokenValidation.message
    }
  }
  
  const { userId, username, nickname, email, avatar, role, level, permissions, password, points, gender, address, city } = data
  
  try {
    const updateData = {
      updateTime: new Date()
    }
    
    // 基本信息字段
    if (username) updateData.username = username
    if (nickname) updateData.nickname = nickname
    if (email) updateData.email = email
    if (avatar) updateData.avatar = avatar
    if (role) updateData.role = role
    if (level) updateData.level = level
    if (permissions) updateData.permissions = permissions
    
    // 个人信息字段
    if (gender !== undefined && gender !== null) updateData.gender = parseInt(gender)
    if (address) updateData.address = address
    if (city) updateData.city = city
    
    // 密码字段（如果提供）
    if (password) {
      updateData.password = password
      updateData.hasDefaultPassword = false
    }
    
    // 积分字段
    if (points !== undefined && points !== null) {
      updateData.points = Math.max(0, parseInt(points) || 0) // 确保积分不为负数
    }
    
    // 如果指定了userId（管理员功能），更新指定用户；否则更新当前用户
    const targetUserId = userId || tokenValidation.userId
    
    // 如果是管理员操作，需要检查权限
    if (userId && tokenValidation.user.role !== 'admin') {
      return {
        success: false,
        code: 403,
        message: '权限不足'
      }
    }
    
    // 如果要修改用户名，检查是否重复
    if (username) {
      const existingUser = await db.collection('users').where({
        username: username,
        _id: _.neq(targetUserId)
      }).get()
      
      if (existingUser.data.length > 0) {
        return {
          success: false,
          code: 400,
          message: '用户名已存在'
        }
      }
    }
    
    // 如果要修改邮箱，检查是否重复
    if (email) {
      const existingUser = await db.collection('users').where({
        email: email,
        _id: _.neq(targetUserId)
      }).get()
      
      if (existingUser.data.length > 0) {
        return {
          success: false,
          code: 400,
          message: '邮箱已被使用'
        }
      }
    }
    
    await db.collection('users').doc(targetUserId).update({
      data: updateData
    })
    
    return {
      success: true,
      code: 200,
      message: '用户信息更新成功'
    }
  } catch (error) {
    console.error('更新用户信息错误:', error)
    return {
      success: false,
      code: 500,
      message: '更新用户信息失败'
    }
  }
}

// 修改密码（需要旧密码）
async function changePassword(data, token) {
  try {
    const tokenValidation = await validateToken(token)
    
    if (!tokenValidation.valid) {
      return {
        success: false,
        message: tokenValidation.message
      }
    }
    
    const user = tokenValidation.user
    const { oldPassword, newPassword } = data
    
    if (!oldPassword || !newPassword) {
      return {
        success: false,
        message: '旧密码和新密码不能为空'
      }
    }
    
    // 明文比对旧密码
    if (user.password !== oldPassword) {
      return {
        success: false,
        message: '旧密码错误'
      }
    }
    
    // 明文存储新密码
    await db.collection('users').doc(tokenValidation.userId).update({
      data: {
        password: newPassword,
        hasDefaultPassword: false,
        updateTime: new Date()
      }
    })
    
    return {
      success: true,
      message: '密码修改成功'
    }
  } catch (error) {
    console.error('修改密码失败:', error)
    return {
      success: false,
      message: '修改密码失败'
    }
  }
}

// 修改密码（不需要旧密码，用于首次修改默认密码）
async function changePasswordWithoutOld(data, token) {
  console.log('changePasswordWithoutOld 开始执行，数据:', JSON.stringify(data, null, 2))
  
  try {
    console.log('开始验证Token')
    const tokenValidation = await validateToken(token)
    console.log('Token验证结果:', tokenValidation.valid ? '成功' : '失败')
    
    if (!tokenValidation.valid) {
      console.log('Token验证失败:', tokenValidation.message)
      return {
        success: false,
        message: tokenValidation.message
      }
    }
    
    console.log('Token验证成功，用户ID:', tokenValidation.userId)
    
    const { newPassword } = data
    console.log('要更新的新密码:', newPassword ? '已提供' : '未提供')
    
    if (!newPassword) {
      console.log('新密码为空')
      return {
        success: false,
        message: '新密码不能为空'
      }
    }
    
    console.log('准备更新用户ID:', tokenValidation.userId)
    
    // 先检查用户是否存在
    const userCheck = await db.collection('users').doc(tokenValidation.userId).get()
    console.log('更新前用户检查:', userCheck.data ? '用户存在' : '用户不存在')
    
    if (!userCheck.data) {
      console.log('用户不存在，无法更新密码')
      return {
        success: false,
        message: '用户不存在'
      }
    }
    
    // 明文存储密码，不进行加密
    const updateResult = await db.collection('users').doc(tokenValidation.userId).update({
      data: {
        password: newPassword,
        hasDefaultPassword: false,
        updateTime: new Date()
      }
    })
    
    console.log('数据库更新结果:', updateResult)
    
    // 验证更新是否成功
    const verifyResult = await db.collection('users').doc(tokenValidation.userId).get()
    console.log('更新后验证 - 用户存在:', verifyResult.data ? true : false)
    console.log('更新后验证 - hasDefaultPassword:', verifyResult.data ? verifyResult.data.hasDefaultPassword : 'N/A')
    console.log('更新后验证 - 密码已更改:', verifyResult.data ? (verifyResult.data.password === newPassword) : 'N/A')
    
    return {
      success: true,
      message: '密码修改成功'
    }
  } catch (error) {
    console.error('修改密码失败，错误详情:', error)
    return {
      success: false,
      message: '修改密码失败: ' + error.message
    }
  }
}

// 获取用户列表（管理员功能）
async function getUserList(data, token) {
  // 验证token
  const tokenValidation = await validateToken(token)
  if (!tokenValidation.valid) {
    return {
      success: false,
      code: 401,
      message: tokenValidation.message
    }
  }
  
  // 检查管理员权限
  if (tokenValidation.user.role !== 'admin') {
    return {
      success: false,
      code: 403,
      message: '权限不足'
    }
  }
  
  const { page = 1, limit = 20, keyword = '' } = data
  
  try {
    let query = db.collection('users')
    
    // 如果有搜索关键词
    if (keyword) {
      query = query.where(_.or([
        { username: new RegExp(keyword) },
        { phone: new RegExp(keyword) },
        { email: new RegExp(keyword) },
        { nickname: new RegExp(keyword) }
      ]))
    }
    
    const countResult = await query.count()
    const total = countResult.total
    
    const userResult = await query
      .orderBy('createTime', 'desc')
      .skip((page - 1) * limit)
      .limit(limit)
      .get()
    
    const users = userResult.data.map(user => {
      delete user.password
      delete user.openid
      return {
        ...user,
        id: user._id
      }
    })
    
    return {
      success: true,
      code: 200,
      message: '获取用户列表成功',
      data: {
        users,
        pagination: {
          page,
          limit,
          total,
          totalPages: Math.ceil(total / limit)
        }
      }
    }
  } catch (error) {
    console.error('获取用户列表错误:', error)
    return {
      success: false,
      code: 500,
      message: '获取用户列表失败'
    }
  }
}

// 重置用户密码（管理员功能）
async function resetPassword(data, token) {
  try {
    const tokenValidation = await validateToken(token)
    
    if (!tokenValidation.valid) {
      return {
        success: false,
        message: tokenValidation.message
      }
    }
    
    // 检查管理员权限
    if (tokenValidation.user.role !== 'admin') {
      return {
        success: false,
        message: '无权限执行此操作'
      }
    }
    
    const { userId, newPassword } = data
    
    if (!userId || !newPassword) {
      return {
        success: false,
        message: '用户ID和新密码不能为空'
      }
    }
    
    // 明文存储密码
    await db.collection('users').doc(userId).update({
      data: {
        password: newPassword,
        hasDefaultPassword: false,
        updateTime: new Date()
      }
    })
    
    return {
      success: true,
      message: '密码重置成功'
    }
  } catch (error) {
    console.error('重置密码失败:', error)
    return {
      success: false,
      message: '重置密码失败'
    }
  }
}

// 设置用户状态（管理员功能）
async function setUserStatus(data, token) {
  // 验证token
  const tokenValidation = await validateToken(token)
  if (!tokenValidation.valid) {
    return {
      success: false,
      code: 401,
      message: tokenValidation.message
    }
  }
  
  // 检查管理员权限
  if (tokenValidation.user.role !== 'admin') {
    return {
      success: false,
      code: 403,
      message: '权限不足'
    }
  }
  
  const { userId, status } = data
  
  if (!userId || !status) {
    return {
      success: false,
      code: 400,
      message: '用户ID和状态不能为空'
    }
  }
  
  try {
    await db.collection('users').doc(userId).update({
      data: {
        status: status,
        updateTime: new Date()
      }
    })
    
    return {
      success: true,
      code: 200,
      message: '用户状态更新成功'
    }
  } catch (error) {
    console.error('设置用户状态错误:', error)
    return {
      success: false,
      code: 500,
      message: '设置用户状态失败'
    }
  }
}

// 删除用户（管理员功能）
async function deleteUser(data, token) {
  // 验证token
  const tokenValidation = await validateToken(token)
  if (!tokenValidation.valid) {
    return {
      success: false,
      code: 401,
      message: tokenValidation.message
    }
  }
  
  // 检查管理员权限
  if (tokenValidation.user.role !== 'admin') {
    return {
      success: false,
      code: 403,
      message: '权限不足'
    }
  }
  
  const { userId } = data
  
  if (!userId) {
    return {
      success: false,
      code: 400,
      message: '用户ID不能为空'
    }
  }
  
  try {
    // 删除用户
    await db.collection('users').doc(userId).remove()
    
    // 删除用户相关的token
    await db.collection('user_tokens').where({ userId }).remove()
    
    return {
      success: true,
      code: 200,
      message: '用户删除成功'
    }
  } catch (error) {
    console.error('删除用户错误:', error)
    return {
      success: false,
      code: 500,
      message: '删除用户失败'
    }
  }
}

// 获取用户统计信息
async function getUserStats(token) {
  // 验证token
  const tokenValidation = await validateToken(token)
  if (!tokenValidation.valid) {
    return {
      success: false,
      code: 401,
      message: tokenValidation.message
    }
  }
  
  try {
    // 获取总用户数
    const totalUsersResult = await db.collection('users').count()
    
    // 获取活跃用户数（最近7天登录）
    const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000)
    const activeUsersResult = await db.collection('users')
      .where({
        lastLoginTime: _.gte(sevenDaysAgo)
      })
      .count()
    
    // 获取今日新增用户数
    const today = new Date()
    today.setHours(0, 0, 0, 0)
    const newUsersResult = await db.collection('users')
      .where({
        createTime: _.gte(today)
      })
      .count()
    
    // 获取VIP用户数
    const vipUsersResult = await db.collection('users')
      .where({
        role: 'vip'
      })
      .count()
    
    return {
      success: true,
      code: 200,
      message: '获取统计信息成功',
      data: {
        totalUsers: totalUsersResult.total,
        activeUsers: activeUsersResult.total,
        newUsers: newUsersResult.total,
        vipUsers: vipUsersResult.total
      }
    }
  } catch (error) {
    console.error('获取用户统计错误:', error)
    return {
      success: false,
      code: 500,
      message: '获取统计信息失败'
    }
  }
} 